﻿namespace NEvoWeb.Modules.NB_Store
{
    using DotNetNuke.Entities.Modules;
    using DotNetNuke.Services.Exceptions;
    using DotNetNuke.Services.Localization;
    using Microsoft.VisualBasic.CompilerServices;
    using System;
    using System.Collections;
    using System.Runtime.CompilerServices;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    using System.Xml;

    public class CheckOutSettings : BaseModuleSettings
    {
        [AccessedThroughProperty("chkDisableLoginMsg")]
        private CheckBox _chkDisableLoginMsg;
        [AccessedThroughProperty("chkGateway")]
        private CheckBoxList _chkGateway;
        [AccessedThroughProperty("chkHideCountry")]
        private CheckBox _chkHideCountry;
        [AccessedThroughProperty("chkHideChq")]
        private CheckBox _chkHideChq;
        [AccessedThroughProperty("chkHideExtraInfo")]
        private CheckBox _chkHideExtraInfo;
        [AccessedThroughProperty("chkHidePromo")]
        private CheckBox _chkHidePromo;
        [AccessedThroughProperty("chkHideShip")]
        private CheckBox _chkHideShip;
        [AccessedThroughProperty("chkHideShipInCart")]
        private CheckBox _chkHideShipInCart;
        [AccessedThroughProperty("chkHideVAT")]
        private CheckBox _chkHideVAT;
        [AccessedThroughProperty("chkLEncapGateway")]
        private CheckBoxList _chkLEncapGateway;
        [AccessedThroughProperty("chkMinimumValidate")]
        private CheckBox _chkMinimumValidate;
        [AccessedThroughProperty("chkNonUserOrder")]
        private CheckBox _chkNonUserOrder;
        [AccessedThroughProperty("chkShowDiscountCol")]
        private CheckBox _chkShowDiscountCol;
        [AccessedThroughProperty("chkShowShipMethod")]
        private CheckBox _chkShowShipMethod;
        [AccessedThroughProperty("chkShowStageHeader")]
        private CheckBox _chkShowStageHeader;
        [AccessedThroughProperty("chkSkipCart")]
        private CheckBox _chkSkipCart;
        [AccessedThroughProperty("chkSmoothLogin")]
        private CheckBox _chkSmoothLogin;
        [AccessedThroughProperty("chkStockChq")]
        private CheckBox _chkStockChq;
        [AccessedThroughProperty("ddlSmoothLoginTab")]
        private DropDownList _ddlSmoothLoginTab;
        [AccessedThroughProperty("lstTabContShop")]
        private DropDownList _lstTabContShop;
        [AccessedThroughProperty("lstTabs")]
        private DropDownList _lstTabs;
        [AccessedThroughProperty("plChequeGateway")]
        private UserControl _plChequeGateway;
        [AccessedThroughProperty("plDisableLoginMsg")]
        private UserControl _plDisableLoginMsg;
        [AccessedThroughProperty("plGateway")]
        private UserControl _plGateway;
        [AccessedThroughProperty("plGatewayDisplay")]
        private UserControl _plGatewayDisplay;
        [AccessedThroughProperty("plHideCountry")]
        private UserControl _plHideCountry;
        [AccessedThroughProperty("plHideChq")]
        private UserControl _plHideChq;
        [AccessedThroughProperty("plHideExtraInfo")]
        private UserControl _plHideExtraInfo;
        [AccessedThroughProperty("plHidePromo")]
        private UserControl _plHidePromo;
        [AccessedThroughProperty("plHideShip")]
        private UserControl _plHideShip;
        [AccessedThroughProperty("plHideShipInCart")]
        private UserControl _plHideShipInCart;
        [AccessedThroughProperty("plHideVAT")]
        private UserControl _plHideVAT;
        [AccessedThroughProperty("plMinimumValidate")]
        private UserControl _plMinimumValidate;
        [AccessedThroughProperty("plNonUserOrder")]
        private UserControl _plNonUserOrder;
        [AccessedThroughProperty("plShowDiscountCol")]
        private UserControl _plShowDiscountCol;
        [AccessedThroughProperty("plShowShipMethod")]
        private UserControl _plShowShipMethod;
        [AccessedThroughProperty("plShowStageHeader")]
        private UserControl _plShowStageHeader;
        [AccessedThroughProperty("plSkipCart")]
        private UserControl _plSkipCart;
        [AccessedThroughProperty("plSmoothLogin")]
        private UserControl _plSmoothLogin;
        [AccessedThroughProperty("plSmoothLoginTab")]
        private UserControl _plSmoothLoginTab;
        [AccessedThroughProperty("plStockChq")]
        private UserControl _plStockChq;
        [AccessedThroughProperty("plTabContShop")]
        private UserControl _plTabContShop;
        [AccessedThroughProperty("plTabList")]
        private UserControl _plTabList;
        [AccessedThroughProperty("rblGatewayDisplay")]
        private RadioButtonList _rblGatewayDisplay;

        public override void LoadSettings()
        {
            try
            {
                if (!this.Page.IsPostBack)
                {
                    if (this.ModuleSettings.Count == 0)
                    {
                        this.DoReset();
                    }
                    this.populatedGatewayDisplay();
                    this.populateGatewayList();
                    this.populateChequeGatewayList();
                    SharedFunctions.populateTabsList(this.lstTabs, this.PortalSettings, "");
                    SharedFunctions.populateTabsList(this.lstTabContShop, this.PortalSettings, "");
                    SharedFunctions.populateTabsList(this.ddlSmoothLoginTab, this.PortalSettings, this.TabId.ToString());
                    this.LoadBaseSettings();
                }
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        private void populateChequeGatewayList()
        {
            try
            {
                IEnumerator enumerator=null;
                XmlDataDocument document = new XmlDataDocument();
                string xml = SharedFunctions.GetStoreSetting(this.PortalId, "encapsulatedproviders.xml", "None", true);
                document.LoadXml(xml);
                try
                {
                    enumerator = document.SelectNodes("root/gateways/gateway").GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        XmlNode current = (XmlNode) enumerator.Current;
                        ListItem item = new ListItem {
                            Value = current.Attributes["ref"].InnerText,
                            Text = current.SelectSingleNode("name").InnerText
                        };
                        this.chkLEncapGateway.Items.Add(item);
                    }
                }
                finally
                {
                    if (enumerator is IDisposable)
                    {
                        (enumerator as IDisposable).Dispose();
                    }
                }
                string str2 = Conversions.ToString(this.Settings["encapsulatedproviders"]);
                if (str2 != null)
                {
                    string[] strArray = str2.Split(new char[] { ';' });
                    int upperBound = strArray.GetUpperBound(0);
                    for (int i = 0; i <= upperBound; i++)
                    {
                        if (this.chkLEncapGateway.Items.FindByValue(strArray[i]) != null)
                        {
                            this.chkLEncapGateway.Items.FindByValue(strArray[i]).Selected = true;
                        }
                    }
                }
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        private void populatedGatewayDisplay()
        {
            this.rblGatewayDisplay.Items.Clear();
            int num = 1;
            do
            {
                ListItem item = new ListItem {
                    Value = num.ToString(),
                    Text = DotNetNuke.Services.Localization.Localization.GetString("GatewayDisplay" + num.ToString(), this.LocalResourceFile)
                };
                this.rblGatewayDisplay.Items.Add(item);
                num++;
            }
            while (num <= 3);
            this.rblGatewayDisplay.SelectedValue = "1";
            string str = Conversions.ToString(this.Settings["rblGatewayDisplay"]);
            if (this.rblGatewayDisplay.Items.FindByValue(str) != null)
            {
                this.rblGatewayDisplay.SelectedValue = str;
            }
        }

        private void populateGatewayList()
        {
            try
            {
                IEnumerator enumerator=null;
                XmlDataDocument document = new XmlDataDocument();
                string xml = SharedFunctions.GetStoreSetting(this.PortalId, "gatewayproviders.xml", "None", true);
                document.LoadXml(xml);
                try
                {
                    enumerator = document.SelectNodes("root/gateways/gateway").GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        XmlNode current = (XmlNode) enumerator.Current;
                        ListItem item = new ListItem {
                            Value = current.Attributes["ref"].InnerText,
                            Text = current.SelectSingleNode("name").InnerText
                        };
                        this.chkGateway.Items.Add(item);
                    }
                }
                finally
                {
                    if (enumerator is IDisposable)
                    {
                        (enumerator as IDisposable).Dispose();
                    }
                }
                string str2 = Conversions.ToString(this.Settings["gatewayproviders"]);
                if (str2 != null)
                {
                    string[] strArray = str2.Split(new char[] { ';' });
                    int upperBound = strArray.GetUpperBound(0);
                    for (int i = 0; i <= upperBound; i++)
                    {
                        if (this.chkGateway.Items.FindByValue(strArray[i]) != null)
                        {
                            this.chkGateway.Items.FindByValue(strArray[i]).Selected = true;
                        }
                    }
                }
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        private void UpdateChequeGatewaySetting()
        {
            try
            {
                IEnumerator enumerator=null;
                XmlDataDocument document = new XmlDataDocument();
                string xml = SharedFunctions.GetStoreSetting(this.PortalId, "encapsulatedproviders.xml", "None", true);
                document.LoadXml(xml);
                string settingValue = "";
                try
                {
                    enumerator = this.chkLEncapGateway.Items.GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        ListItem current = (ListItem) enumerator.Current;
                        if (current.Selected)
                        {
                            XmlNode node = document.SelectSingleNode("root/gateways/gateway[@ref='" + current.Value + "']");
                            if (node != null)
                            {
                                settingValue = settingValue + node.SelectSingleNode("assembly").InnerText + "," + node.SelectSingleNode("class").InnerText + ";";
                            }
                        }
                    }
                }
                finally
                {
                    if (enumerator is IDisposable)
                    {
                        (enumerator as IDisposable).Dispose();
                    }
                }
                if (settingValue != "")
                {
                    settingValue = settingValue.TrimEnd(new char[] { ';' });
                    SharedFunctions.SetStoreSetting(this.PortalId, "encapsulated.provider", settingValue, "None", true);
                }
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        private void UpdateGatewaySetting()
        {
            try
            {
                IEnumerator enumerator=null;
                XmlDataDocument document = new XmlDataDocument();
                string xml = SharedFunctions.GetStoreSetting(this.PortalId, "gatewayproviders.xml", "None", true);
                document.LoadXml(xml);
                string settingValue = "";
                try
                {
                    enumerator = this.chkGateway.Items.GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        ListItem current = (ListItem) enumerator.Current;
                        if (current.Selected)
                        {
                            XmlNode node = document.SelectSingleNode("root/gateways/gateway[@ref='" + current.Value + "']");
                            if (node != null)
                            {
                                settingValue = settingValue + node.SelectSingleNode("assembly").InnerText + "," + node.SelectSingleNode("class").InnerText + ";";
                            }
                        }
                    }
                }
                finally
                {
                    if (enumerator is IDisposable)
                    {
                        (enumerator as IDisposable).Dispose();
                    }
                }
                settingValue = settingValue.TrimEnd(new char[] { ';' });
                SharedFunctions.SetStoreSetting(this.PortalId, "gateway.provider", settingValue, "None", true);
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        public override void UpdateSettings()
        {
            try
            {
                ListItem current;
                IEnumerator enumerator=null;
                IEnumerator enumerator2=null;
                this.UpdateBaseSettings();
                ModuleController controller = new ModuleController();
                string settingValue = "";
                try
                {
                    enumerator = this.chkLEncapGateway.Items.GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (ListItem) enumerator.Current;
                        if (current.Selected)
                        {
                            settingValue = settingValue + current.Value + ";";
                        }
                    }
                }
                finally
                {
                    if (enumerator is IDisposable)
                    {
                        (enumerator as IDisposable).Dispose();
                    }
                }
                settingValue = settingValue.Trim(new char[] { ';' });
                controller.UpdateModuleSetting(this.ModuleId, "encapsulatedproviders", settingValue);
                settingValue = "";
                try
                {
                    enumerator2 = this.chkGateway.Items.GetEnumerator();
                    while (enumerator2.MoveNext())
                    {
                        current = (ListItem) enumerator2.Current;
                        if (current.Selected)
                        {
                            settingValue = settingValue + current.Value + ";";
                        }
                    }
                }
                finally
                {
                    if (enumerator2 is IDisposable)
                    {
                        (enumerator2 as IDisposable).Dispose();
                    }
                }
                settingValue = settingValue.Trim(new char[] { ';' });
                controller.UpdateModuleSetting(this.ModuleId, "gatewayproviders", settingValue);
                this.UpdateGatewaySetting();
                this.UpdateChequeGatewaySetting();
            }
            catch (Exception exception1)
            {
                ProjectData.SetProjectError(exception1);
                Exception exc = exception1;
                DotNetNuke.Services.Exceptions.Exceptions.ProcessModuleLoadException((PortalModuleBase) this, exc);
                ProjectData.ClearProjectError();
            }
        }

        protected virtual CheckBox chkDisableLoginMsg
        {
            get
            {
                return this._chkDisableLoginMsg;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkDisableLoginMsg = value;
            }
        }

        protected virtual CheckBoxList chkGateway
        {
            get
            {
                return this._chkGateway;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkGateway = value;
            }
        }

        protected virtual CheckBox chkHideCountry
        {
            get
            {
                return this._chkHideCountry;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideCountry = value;
            }
        }

        protected virtual CheckBox chkHideChq
        {
            get
            {
                return this._chkHideChq;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideChq = value;
            }
        }

        protected virtual CheckBox chkHideExtraInfo
        {
            get
            {
                return this._chkHideExtraInfo;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideExtraInfo = value;
            }
        }

        protected virtual CheckBox chkHidePromo
        {
            get
            {
                return this._chkHidePromo;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHidePromo = value;
            }
        }

        protected virtual CheckBox chkHideShip
        {
            get
            {
                return this._chkHideShip;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideShip = value;
            }
        }

        protected virtual CheckBox chkHideShipInCart
        {
            get
            {
                return this._chkHideShipInCart;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideShipInCart = value;
            }
        }

        protected virtual CheckBox chkHideVAT
        {
            get
            {
                return this._chkHideVAT;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkHideVAT = value;
            }
        }

        protected virtual CheckBoxList chkLEncapGateway
        {
            get
            {
                return this._chkLEncapGateway;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkLEncapGateway = value;
            }
        }

        protected virtual CheckBox chkMinimumValidate
        {
            get
            {
                return this._chkMinimumValidate;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkMinimumValidate = value;
            }
        }

        protected virtual CheckBox chkNonUserOrder
        {
            get
            {
                return this._chkNonUserOrder;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkNonUserOrder = value;
            }
        }

        protected virtual CheckBox chkShowDiscountCol
        {
            get
            {
                return this._chkShowDiscountCol;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkShowDiscountCol = value;
            }
        }

        protected virtual CheckBox chkShowShipMethod
        {
            get
            {
                return this._chkShowShipMethod;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkShowShipMethod = value;
            }
        }

        protected virtual CheckBox chkShowStageHeader
        {
            get
            {
                return this._chkShowStageHeader;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkShowStageHeader = value;
            }
        }

        protected virtual CheckBox chkSkipCart
        {
            get
            {
                return this._chkSkipCart;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkSkipCart = value;
            }
        }

        protected virtual CheckBox chkSmoothLogin
        {
            get
            {
                return this._chkSmoothLogin;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkSmoothLogin = value;
            }
        }

        protected virtual CheckBox chkStockChq
        {
            get
            {
                return this._chkStockChq;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._chkStockChq = value;
            }
        }

        protected virtual DropDownList ddlSmoothLoginTab
        {
            get
            {
                return this._ddlSmoothLoginTab;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._ddlSmoothLoginTab = value;
            }
        }

        protected virtual DropDownList lstTabContShop
        {
            get
            {
                return this._lstTabContShop;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._lstTabContShop = value;
            }
        }

        protected virtual DropDownList lstTabs
        {
            get
            {
                return this._lstTabs;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._lstTabs = value;
            }
        }

        protected virtual UserControl plChequeGateway
        {
            get
            {
                return this._plChequeGateway;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plChequeGateway = value;
            }
        }

        protected virtual UserControl plDisableLoginMsg
        {
            get
            {
                return this._plDisableLoginMsg;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plDisableLoginMsg = value;
            }
        }

        protected virtual UserControl plGateway
        {
            get
            {
                return this._plGateway;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plGateway = value;
            }
        }

        protected virtual UserControl plGatewayDisplay
        {
            get
            {
                return this._plGatewayDisplay;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plGatewayDisplay = value;
            }
        }

        protected virtual UserControl plHideCountry
        {
            get
            {
                return this._plHideCountry;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideCountry = value;
            }
        }

        protected virtual UserControl plHideChq
        {
            get
            {
                return this._plHideChq;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideChq = value;
            }
        }

        protected virtual UserControl plHideExtraInfo
        {
            get
            {
                return this._plHideExtraInfo;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideExtraInfo = value;
            }
        }

        protected virtual UserControl plHidePromo
        {
            get
            {
                return this._plHidePromo;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHidePromo = value;
            }
        }

        protected virtual UserControl plHideShip
        {
            get
            {
                return this._plHideShip;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideShip = value;
            }
        }

        protected virtual UserControl plHideShipInCart
        {
            get
            {
                return this._plHideShipInCart;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideShipInCart = value;
            }
        }

        protected virtual UserControl plHideVAT
        {
            get
            {
                return this._plHideVAT;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plHideVAT = value;
            }
        }

        protected virtual UserControl plMinimumValidate
        {
            get
            {
                return this._plMinimumValidate;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plMinimumValidate = value;
            }
        }

        protected virtual UserControl plNonUserOrder
        {
            get
            {
                return this._plNonUserOrder;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plNonUserOrder = value;
            }
        }

        protected virtual UserControl plShowDiscountCol
        {
            get
            {
                return this._plShowDiscountCol;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plShowDiscountCol = value;
            }
        }

        protected virtual UserControl plShowShipMethod
        {
            get
            {
                return this._plShowShipMethod;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plShowShipMethod = value;
            }
        }

        protected virtual UserControl plShowStageHeader
        {
            get
            {
                return this._plShowStageHeader;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plShowStageHeader = value;
            }
        }

        protected virtual UserControl plSkipCart
        {
            get
            {
                return this._plSkipCart;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plSkipCart = value;
            }
        }

        protected virtual UserControl plSmoothLogin
        {
            get
            {
                return this._plSmoothLogin;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plSmoothLogin = value;
            }
        }

        protected virtual UserControl plSmoothLoginTab
        {
            get
            {
                return this._plSmoothLoginTab;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plSmoothLoginTab = value;
            }
        }

        protected virtual UserControl plStockChq
        {
            get
            {
                return this._plStockChq;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plStockChq = value;
            }
        }

        protected virtual UserControl plTabContShop
        {
            get
            {
                return this._plTabContShop;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plTabContShop = value;
            }
        }

        protected virtual UserControl plTabList
        {
            get
            {
                return this._plTabList;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._plTabList = value;
            }
        }

        protected virtual RadioButtonList rblGatewayDisplay
        {
            get
            {
                return this._rblGatewayDisplay;
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            set
            {
                this._rblGatewayDisplay = value;
            }
        }
    }
}

